// 正确的window.onload事件处理函数
window.onload = function() {
    // 获取URL中的参数
    const urlParams = new URLSearchParams(window.location.search);
    const postId = urlParams.get('id');
    const author = urlParams.get('author');
    const content = urlParams.get('content');
    
    // 初始化帖子内容
    if (postId && author && content) {
        // 确保存在postId输入框
        if (document.getElementById('postId')) {
            document.getElementById('postId').value = postId;
        }
        document.getElementById('postAvatar').textContent = author.charAt(0);
        document.getElementById('postAuthor').textContent = author;
        document.getElementById('postTitle').textContent = `帖子 #${postId}`;
        document.getElementById('postContent').textContent = decodeURIComponent(content);
    } else {
        // 如果URL中没有参数，尝试根据ID从服务器获取帖子详情
        if (postId) {
            fetchPostDetails(postId);
        } else {
            document.getElementById('postTitle').textContent = '未找到帖子';
            document.getElementById('postContent').textContent = '请通过有效链接访问帖子详情';
        }
    }
    
    // 绑定事件监听器
    if (document.getElementById('commentForm')) {
        document.getElementById('commentForm').addEventListener('submit', handleCommentSubmit);
    }
    if (document.getElementById('commentButton')) {
        document.getElementById('commentButton').addEventListener('click', function() {
            // 打开评论模态框
            const commentModal = document.getElementById('commentModal');
            if (commentModal) {
                document.getElementById('commentPostId').value = postId;
                commentModal.style.display = 'flex';
                document.getElementById('modalCommentContent').focus();
            } else {
                // 如果没有模态框，直接聚焦到评论输入框
                document.getElementById('commentContent').focus();
            }
        });
    }
    if (document.getElementById('likeButton')) {
        document.getElementById('likeButton').addEventListener('click', handleLike);
    }
    
    // 模态框相关事件
    if (document.getElementById('cancelComment')) {
        document.getElementById('cancelComment').addEventListener('click', function() {
            document.getElementById('commentModal').style.display = 'none';
        });
    }
    if (document.getElementById('confirmComment')) {
        document.getElementById('confirmComment').addEventListener('click', handleModalCommentSubmit);
    }
    
    // 加载评论列表
    if (postId) {
        loadComments(postId);
    }
};

// 从服务器获取帖子详情
function fetchPostDetails(postId) {
    fetch(`/api/post/findPost/${postId}`, {
        method: 'GET',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded'
        }
    })
    .then(response => {
        if (response.status === 200) {
            return response.json();
        } else {
            throw new Error(`获取帖子失败: ${response.status}`);
        }
    })
    .then(data => {
        if (data && data.code === 200 && data.data) {
            const post = data.data;
            document.getElementById('postAvatar').textContent = post.author.charAt(0);
            document.getElementById('postAuthor').textContent = post.author;
            document.getElementById('postTitle').textContent = post.articalName || `帖子 #${postId}`;
            document.getElementById('postContent').textContent = post.content;
        }
    })
    .catch(error => {
        console.error('获取帖子详情失败:', error);
        alert('获取帖子详情失败: ' + error.message);
    });
}

// 处理表单提交评论
function handleCommentSubmit(e) {
    e.preventDefault();
    
    const postId = new URLSearchParams(window.location.search).get('id');
    const content = document.getElementById('commentContent').value.trim();
    
    if (!postId || !content) {
        alert('请填写评论内容');
        return;
    }
    
    // 发布评论
    publishComment({
        content: content,
        postId: postId,
        publisher: getCurrentUserName() // 获取当前用户名称
    });
}

// 处理模态框提交评论
function handleModalCommentSubmit() {
    const postId = document.getElementById('commentPostId').value;
    const content = document.getElementById('modalCommentContent').value.trim();
    
    if (!postId || !content) {
        alert('请填写评论内容');
        return;
    }
    
    // 发布评论
    publishComment({
        content: content,
        postId: postId,
        publisher: getCurrentUserName() // 获取当前用户名称
    });
    
    // 关闭模态框
    document.getElementById('commentModal').style.display = 'none';
    document.getElementById('modalCommentContent').value = '';
}

// 发布评论函数 - 修复版（解决HTTP头部编码问题）
function publishComment(commentDto) {
    console.log('尝试发布评论，数据:', commentDto);
    
    // 模拟获取用户信息
    const userId = 1; // 假设用户ID为1
    
    // 重要：HTTP头部不能包含中文字符，这里只使用用户ID作为Authorization
    // 实际应用中，应该使用token或其他不包含非ASCII字符的认证方式
    
    // 调用发布评论接口
    fetch('/api/comment/publish', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            // 修复：只使用用户ID作为Authorization，避免中文问题
            'Authorization': userId.toString()
        },
        // 确保请求体中的publisher字段仍然包含用户名
        body: JSON.stringify(commentDto)
    })
    .then(response => {
        console.log('评论发布请求已发送，状态码:', response.status);
        
        // 首先检查响应是否正常
        if (!response.ok) {
            throw new Error(`服务器响应错误: ${response.status}`);
        }
        
        // 尝试解析JSON，但处理可能的空响应
        return response.text().then(text => {
            try {
                return text ? JSON.parse(text) : { message: '评论发布成功' };
            } catch (e) {
                console.warn('无法解析响应为JSON，使用默认消息');
                return { message: '评论发布成功' };
            }
        });
    })
    .then(data => {
        console.log('评论发布成功，服务器返回:', data);
        
        // 清空评论输入框
        if (document.getElementById('commentContent')) {
            document.getElementById('commentContent').value = '';
        }
        
        // 重新加载评论列表
        loadComments(commentDto.postId);
        
        // 显示成功提示
        alert(data.message || '评论发布成功');
    })
    .catch(error => {
        console.error('评论发布失败:', error);
        alert('评论发布失败: ' + error.message);
    });
}

// 加载评论列表
function loadComments(postId) {
    console.log('准备加载文章评论，postId:', postId);
    
    // 调用查找文章所有评论ID的接口
    fetch(`/api/comment/find/ids/${postId}`, {
        method: 'GET',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded'
        }
    })
    .then(response => {
        console.log('获取评论ID列表请求已发送，状态码:', response.status);
        
        // 检查响应状态
        if (response.status === 200) {
            return response.text().then(text => {
                try {
                    return text ? JSON.parse(text) : { code: 200, message: 'success', data: [] };
                } catch (error) {
                    console.error('解析响应失败:', error);
                    // 返回默认的空评论列表
                    return { code: 200, message: 'success', data: [] };
                }
            });
        } else {
            throw new Error(`获取评论ID列表失败: ${response.status}`);
        }
    })
    .then(data => {
        if (data && data.code === 200 && Array.isArray(data.data)) {
            const commentIds = data.data;
            console.log('获取评论ID列表成功，评论数量:', commentIds.length);
            
            // 根据评论ID列表获取所有评论详情
            fetchAllCommentsDetails(commentIds)
                .then(comments => {
                    renderComments(comments);
                })
                .catch(error => {
                    console.error('获取评论详情失败:', error);
                    alert('获取评论详情失败: ' + error.message);
                    
                    // 降级使用模拟数据
                    const mockComments = generateMockComments(commentIds);
                    renderComments(mockComments);
                });
        } else {
            console.error('获取评论ID列表失败，响应数据格式错误:', data);
            // 显示空评论列表
            renderComments([]);
        }
    })
    .catch(error => {
        console.error('获取评论ID列表失败:', error);
        alert('获取评论列表失败: ' + error.message);
        
        // 为了演示，我们使用模拟数据
        const mockComments = [
            {
                id: 1,
                content: '这是一条评论示例',
                publisher: '用户A',
                createTime: new Date(Date.now() - 3600000).toLocaleString()
            },
            {
                id: 2,
                content: '非常感谢分享！',
                publisher: '用户B',
                createTime: new Date(Date.now() - 7200000).toLocaleString()
            }
        ];
        renderComments(mockComments);
    });
}

// 根据评论ID列表获取所有评论详情
function fetchAllCommentsDetails(commentIds) {
    return Promise.all(commentIds.map(commentId => fetchCommentById(commentId)))
        .then(comments => {
            // 过滤掉获取失败的评论，并按照发布时间降序排序
            return comments
                .filter(comment => comment !== null)
                .sort((a, b) => new Date(b.createTime || b.publishTime) - new Date(a.createTime || a.publishTime));
        });
}

// 根据评论ID获取单条评论详情
function fetchCommentById(commentId) {
    console.log('准备获取评论详情，commentId:', commentId);
    
    return fetch(`/api/comment/find/${commentId}`, {
        method: 'GET',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded'
        }
    })
    .then(response => {
        console.log('获取评论详情请求已发送，状态码:', response.status);
        
        // 检查响应状态
        if (response.status === 200) {
            return response.text().then(text => {
                try {
                    const data = text ? JSON.parse(text) : null;
                    if (data && data.code === 200 && data.data) {
                        // 转换评论数据格式，使其与现有的渲染逻辑兼容
                        const commentData = data.data;
                        return {
                            id: commentData.id,
                            content: commentData.content,
                            publisher: commentData.publisher,
                            createTime: commentData.publishTime || new Date().toLocaleString()
                        };
                    } else {
                        console.error('获取评论详情失败，响应数据格式错误:', data);
                        return null;
                    }
                } catch (error) {
                    console.error('解析评论详情响应失败:', error);
                    return null;
                }
            });
        } else if (response.status === 404) {
            console.warn('评论不存在，commentId:', commentId);
            return null;
        } else {
            throw new Error(`获取评论详情失败: ${response.status}`);
        }
    })
    .catch(error => {
        console.error('获取评论详情失败:', error);
        // 返回null而不是抛出错误，这样其他评论仍然可以获取
        return null;
    });
}

// 根据评论ID生成模拟评论数据
function generateMockComments(commentIds) {
    const mockComments = [];
    const publishers = ['用户A', '用户B', '用户C', '用户D', '用户E'];
    
    commentIds.forEach(id => {
        // 为每个ID生成随机评论内容
        const contents = [
            '非常好的内容，谢谢分享！',
            '这个观点很有见地，值得深思。',
            '学习了，期待更多优质内容。',
            '我有不同的看法，欢迎讨论。',
            '感谢分享，对我很有帮助。'
        ];
        
        const randomPublisher = publishers[Math.floor(Math.random() * publishers.length)];
        const randomContent = contents[Math.floor(Math.random() * contents.length)];
        const randomTime = new Date(Date.now() - Math.random() * 86400000 * 7).toLocaleString(); // 随机7天内的时间
        
        mockComments.push({
            id: id,
            content: randomContent,
            publisher: randomPublisher,
            createTime: randomTime
        });
    });
    
    return mockComments;
}

// 渲染评论列表
function renderComments(comments) {
    const commentsList = document.getElementById('commentsList');
    const commentsTitle = document.querySelector('.comments-title');
    
    // 更新评论数量
    commentsTitle.textContent = `评论 (${comments.length})`;
    
    // 清空现有评论
    commentsList.innerHTML = '';
    
    // 渲染每条评论
    comments.forEach(comment => {
        const commentItem = document.createElement('div');
        commentItem.className = 'comment-item';
        commentItem.setAttribute('data-comment-id', comment.id);
        
        commentItem.innerHTML = `
            <div class="comment-header">
                <span class="comment-author">${comment.publisher}</span>
                <span class="comment-time">${comment.createTime}</span>
                <button class="delete-comment-btn" data-comment-id="${comment.id}">删除</button>
            </div>
            <div class="comment-content">${comment.content}</div>
        `;
        
        commentsList.appendChild(commentItem);
    });
    
    // 为所有删除按钮添加点击事件
    addDeleteCommentListeners();
}

// 为删除评论按钮添加事件监听器
function addDeleteCommentListeners() {
    const deleteButtons = document.querySelectorAll('.delete-comment-btn');
    deleteButtons.forEach(button => {
        button.addEventListener('click', function() {
            const commentId = parseInt(this.getAttribute('data-comment-id'));
            confirmDeleteComment(commentId);
        });
    });
}

// 确认删除评论
function confirmDeleteComment(commentId) {
    if (window.confirm('确定要删除这条评论吗？')) {
        deleteComment(commentId);
    }
}

// 删除评论函数 - 按照接口规范实现
function deleteComment(commentId) {
    console.log('准备删除评论，ID:', commentId);
    
    // 模拟获取用户信息
    const userId = 1; // 假设用户ID为1
    
    // 调用删除评论接口
    fetch(`/api/comment/delete?commentId=${commentId}`, {
        method: 'DELETE',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Authorization': userId.toString() // 使用用户ID作为认证信息
        }
    })
    .then(response => {
        console.log('删除评论请求已发送，状态码:', response.status);
        
        // 检查响应状态
        if (response.status === 200 || response.status === 204) {
            // 尝试解析JSON响应（204可能没有响应体）
            if (response.status === 200) {
                return response.text().then(text => {
                    try {
                        return text ? JSON.parse(text) : { message: '删除成功' };
                    } catch (e) {
                        console.warn('无法解析响应为JSON，使用默认消息');
                        return { message: '删除成功' };
                    }
                });
            } else {
                return { message: '删除成功' };
            }
        } else if (response.status === 401) {
            throw new Error('未授权，请先登录');
        } else if (response.status === 403) {
            throw new Error('没有权限删除这条评论');
        } else {
            throw new Error(`删除失败: 服务器返回 ${response.status}`);
        }
    })
    .then(data => {
        console.log('删除评论成功，服务器返回:', data);
        
        // 从页面中移除被删除的评论
        removeCommentFromDOM(commentId);
        
        // 更新评论数量
        updateCommentsCount();
        
        // 显示成功提示
        alert(data.message || '删除成功');
    })
    .catch(error => {
        console.error('删除评论失败:', error);
        alert('删除评论失败: ' + error.message);
    });
}

// 从DOM中移除被删除的评论
function removeCommentFromDOM(commentId) {
    const commentElement = document.querySelector(`.comment-item[data-comment-id="${commentId}"]`);
    if (commentElement) {
        // 添加淡出动画
        commentElement.style.transition = 'opacity 0.3s ease-out';
        commentElement.style.opacity = '0';
        
        // 动画结束后移除元素
        setTimeout(() => {
            commentElement.remove();
            updateCommentsCount();
        }, 300);
    }
}

// 更新评论数量
function updateCommentsCount() {
    const commentsList = document.getElementById('commentsList');
    const commentsTitle = document.querySelector('.comments-title');
    const commentsCount = commentsList.querySelectorAll('.comment-item').length;
    commentsTitle.textContent = `评论 (${commentsCount})`;
}

// 处理点赞
function handleLike() {
    const postId = new URLSearchParams(window.location.search).get('id');
    const likeButton = document.getElementById('likeButton');
    
    if (!postId) {
        alert('无法点赞，未找到帖子ID');
        return;
    }
    
    // 切换点赞状态
    if (likeButton.textContent === '点赞') {
        likePost(postId);
        likeButton.textContent = '已点赞';
        likeButton.style.backgroundColor = '#4CAF50';
        likeButton.style.color = 'white';
    } else {
        unlikePost(postId);
        likeButton.textContent = '点赞';
        likeButton.style.backgroundColor = '#f0f0f0';
        likeButton.style.color = 'black';
    }
}

// 点赞函数（这里使用study.js中已有的逻辑）
function likePost(postId) {
    console.log('尝试点赞帖子，ID:', postId);
    
    // 模拟用户ID（实际应用中可能从登录状态获取）
    const userId = 1; // 这里假设用户ID为1
    
    // 调用点赞接口
    fetch('/api/post/like', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            articalId: postId,
            userId: userId
        })
    })
    .then(response => {
        if (!response.ok) {
            throw new Error(`服务器响应错误: ${response.status}`);
        }
        return response.json();
    })
    .catch(error => {
        console.error('点赞失败:', error);
    });
}

// 取消点赞函数（这里使用study.js中已有的逻辑）
function unlikePost(postId) {
    console.log('尝试取消点赞帖子，ID:', postId);
    
    // 模拟用户ID
    const userId = 1;
    
    // 调用取消点赞接口
    fetch('/api/post/unlike', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({
            articalId: postId,
            userId: userId
        })
    })
    .then(response => {
        if (!response.ok) {
            throw new Error(`服务器响应错误: ${response.status}`);
        }
        return response.json();
    })
    .catch(error => {
        console.error('取消点赞失败:', error);
    });
}

// 获取当前用户名（实际应用中应该从登录状态获取）
function getCurrentUserName() {
    // 模拟获取当前用户名
    // 实际应用中，应该从登录状态、localStorage或Cookie中获取
    return '当前用户';
}